import { request } from 'umi';
import { message } from 'antd';
import { handleApiError } from '../utils';

/**
 * 基础服务类
 */
class BaseService {
  constructor(baseUrl) {
    this.baseUrl = baseUrl;
  }

  /**
   * 发送GET请求
   * @param {string} endpoint - 接口端点
   * @param {object} params - 查询参数
   * @param {object} options - 额外选项
   * @returns {Promise} 响应数据
   */
  async get(endpoint, params = {}, options = {}) {
    try {
      const response = await request(`${this.baseUrl}${endpoint}`, {
        method: 'GET',
        params,
        ...options,
      });
      return this.handleResponse(response);
    } catch (error) {
      this.handleError(error);
      throw error;
    }
  }

  /**
   * 发送POST请求
   * @param {string} endpoint - 接口端点
   * @param {object} data - 请求数据
   * @param {object} options - 额外选项
   * @returns {Promise} 响应数据
   */
  async post(endpoint, data = {}, options = {}) {
    try {
      const response = await request(`${this.baseUrl}${endpoint}`, {
        method: 'POST',
        data,
        ...options,
      });
      return this.handleResponse(response);
    } catch (error) {
      this.handleError(error);
      throw error;
    }
  }

  /**
   * 发送PUT请求
   * @param {string} endpoint - 接口端点
   * @param {object} data - 请求数据
   * @param {object} options - 额外选项
   * @returns {Promise} 响应数据
   */
  async put(endpoint, data = {}, options = {}) {
    try {
      const response = await request(`${this.baseUrl}${endpoint}`, {
        method: 'PUT',
        data,
        ...options,
      });
      return this.handleResponse(response);
    } catch (error) {
      this.handleError(error);
      throw error;
    }
  }

  /**
   * 发送DELETE请求
   * @param {string} endpoint - 接口端点
   * @param {object} params - 查询参数
   * @param {object} options - 额外选项
   * @returns {Promise} 响应数据
   */
  async delete(endpoint, params = {}, options = {}) {
    try {
      const response = await request(`${this.baseUrl}${endpoint}`, {
        method: 'DELETE',
        params,
        ...options,
      });
      return this.handleResponse(response);
    } catch (error) {
      this.handleError(error);
      throw error;
    }
  }

  /**
   * 处理响应数据
   * @param {object} response - 响应对象
   * @returns {object} 处理后的数据
   */
  handleResponse(response) {
    if (response.success === false) {
      throw new Error(response.message || '请求失败');
    }
    return response.data;
  }

  /**
   * 处理错误
   * @param {object} error - 错误对象
   */
  handleError(error) {
    const errorMessage = handleApiError(error);
    message.error(errorMessage);
    console.error('API Error:', error);
  }

  /**
   * 批量请求
   * @param {array} requests - 请求配置数组
   * @returns {Promise} 所有响应数据
   */
  async batch(requests) {
    try {
      const promises = requests.map(({ endpoint, params, data, method = 'GET' }) => {
        return request(`${this.baseUrl}${endpoint}`, {
          method,
          params,
          data,
        });
      });

      const responses = await Promise.all(promises);
      return responses.map(this.handleResponse);
    } catch (error) {
      this.handleError(error);
      throw error;
    }
  }
}

/**
 * 美团配置服务
 */
export class MeituanConfigService extends BaseService {
  constructor() {
    super('/api/meituan');
  }

  /**
   * 获取美团配置列表
   */
  async getList(params) {
    return this.get('/', params);
  }

  /**
   * 创建美团配置
   */
  async create(data) {
    return this.post('/', data);
  }

  /**
   * 获取美团配置详情
   */
  async getDetail(id) {
    return this.get(`/${id}`);
  }

  /**
   * 更新美团配置
   */
  async update(id, data) {
    return this.put(`/${id}`, data);
  }

  /**
   * 删除美团配置
   */
  async delete(id) {
    return this.delete(`/${id}`);
  }

  /**
   * 获取订单列表
   */
  async getOrderList(params) {
    return this.get('/order', params);
  }

  /**
   * 获取订单详情
   */
  async getOrderDetail(id) {
    return this.get(`/order/${id}`);
  }

  /**
   * 处理订单
   */
  async processOrder(data) {
    return this.post('/order/process', data);
  }

  /**
   * 同步测试
   */
  async syncTest(id) {
    return this.post(`/sync/${id}`);
  }
}

/**
 * 美团团购服务
 */
export class MeituanGroupService extends BaseService {
  constructor() {
    super('/api/meituan/group');
  }

  /**
   * 获取团购活动列表
   */
  async getList(params) {
    return this.get('/', params);
  }

  /**
   * 创建团购活动
   */
  async create(data) {
    return this.post('/', data);
  }

  /**
   * 获取团购活动详情
   */
  async getDetail(id) {
    return this.get(`/${id}`);
  }

  /**
   * 更新团购活动
   */
  async update(id, data) {
    return this.put(`/${id}`, data);
  }

  /**
   * 删除团购活动
   */
  async delete(id) {
    return this.delete(`/${id}`);
  }

  /**
   * 获取订单列表
   */
  async getOrderList(params) {
    return this.get('/order', params);
  }

  /**
   * 获取订单详情
   */
  async getOrderDetail(id) {
    return this.get(`/order/${id}`);
  }

  /**
   * 处理订单
   */
  async processOrder(data) {
    return this.post('/order/process', data);
  }

  /**
   * 使用团购券
   */
  async useVoucher(id) {
    return this.post(`/order/use/${id}`);
  }

  /**
   * 同步订单
   */
  async syncOrders(params) {
    return this.post('/order/sync', params);
  }
}

/**
 * 公共数据服务
 */
export class CommonService extends BaseService {
  constructor() {
    super('/api');
  }

  /**
   * 获取门店列表
   */
  async getStores(params = {}) {
    return this.get('/store', { ...params, page_size: 1000 });
  }

  /**
   * 获取城市列表
   */
  async getCities() {
    return this.get('/city/all');
  }

  /**
   * 获取字典数据
   */
  async getDict(type) {
    const dictMap = {
      order_status: [
        { value: 'WAITING_CONFIRM', label: '待确认' },
        { value: 'CONFIRMED', label: '已确认' },
        { value: 'COMPLETED', label: '已完成' },
        { value: 'CANCELLED', label: '已取消' },
      ],
      process_status: [
        { value: 'pending', label: '待处理' },
        { value: 'accepted', label: '已接单' },
        { value: 'rejected', label: '已拒绝' },
        { value: 'completed', label: '已完成' },
      ],
    };
    
    return Promise.resolve(dictMap[type] || []);
  }
}

// 创建服务实例
export const meituanConfigService = new MeituanConfigService();
export const meituanGroupService = new MeituanGroupService();
export const commonService = new CommonService();